Eliminating intermediate lists in pH using local transformations

Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1994.Includes bibliographical references (p. 68-69).by Jan-Willem Maessen.M.Eng

Store Atomicity for Transactional Memory

AbstractWe extend the notion of Store Atomicity [Arvind and Jan-Willem Maessen. Memory model = instruction reordering + store atomicity. In ISCA '06: Proceedings of the 33rd annual International Symposium on Computer Architecture, 2006] to a system with atomic transactional memory. This gives a fine-grained graph-based framework for defining and reasoning about transactional memory consistency. The memory model is defined in terms of thread-local Instruction Reordering axioms and Store Atomicity, which describes inter-thread communication via memory. A memory model with Store Atomicity is serializable: there is a unique global interleaving of all operations which respects the reordering rules and serializes all the operations in a transaction together. We extend Store Atomicity to capture this ordering requirement by requiring dependencies which cross a transaction boundary to point in to the initiating instruction or out from the committing instruction. We sketch a weaker definition of transactional serialization which accounts for the ability to interleave transactional operations which touch disjoint memory. We give a procedure for enumerating the behaviors of a transactional program—noting that a safe enumeration procedure permits only one transaction to read from memory at a time. We show that more realistic models of transactional execution require speculative execution. We define the conditions under which speculation must be rolled back, and give criteria to identify which instructions must be rolled back in these cases

Hybrid eager and lazy evaluation for efficient compilation of Haskell

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2002.Includes bibliographical references (p. 208-220).This electronic version was submitted by the student author. The certified thesis is available in the Institute Archives and Special Collections.The advantage of a non-strict, purely functional language such as Haskell lies in its clean equational semantics. However, lazy implementations of Haskell fall short: they cannot express tail recursion gracefully without annotation. We describe resource-bounded hybrid evaluation, a mixture of strict and lazy evaluation, and its realization in Eager Haskell. From the programmer's perspective, Eager Haskell is simply another implementation of Haskell with the same clean equational semantics. Iteration can be expressed using tail recursion, without the need to resort to program annotations. Under hybrid evaluation, computations are ordinarily executed in program order just as in a strict functional language. When particular stack, heap, or time bounds are exceeded, suspensions are generated for all outstanding computations. These suspensions are re-started in a demand-driven fashion from the root. The Eager Haskell compiler translates Ac, the compiler's intermediate representation, to efficient C code. We use an equational semantics for Ac to develop simple correctness proofs for program transformations, and connect actions in the run-time system to steps in the hybrid evaluation strategy.(cont.) The focus of compilation is efficiency in the common case of straight-line execution; the handling of non-strictness and suspension are left to the run-time system. Several additional contributions have resulted from the implementation of hybrid evaluation. Eager Haskell is the first eager compiler to use a call stack. Our generational garbage collector uses this stack as an additional predictor of object lifetime. Objects above a stack watermark are assumed to be likely to die; we avoid promoting them. Those below are likely to remain untouched and therefore are good candidates for promotion. To avoid eagerly evaluating error checks, they are compiled into special bottom thunks, which are treated specially by the run-time system. The compiler identifies error handling code using a mixture of strictness and type information. This information is also used to avoid inlining error handlers, and to enable aggressive program transformation in the presence of error handling.by Jan-Willem Maessen.Ph.D

Endosonography With or Without Confirmatory Mediastinoscopy for Resectable Lung Cancer:A Randomized Clinical Trial

PURPOSE:Resectable non-small-cell lung cancer (NSCLC) with a high probability of mediastinal nodal involvement requires mediastinal staging by endosonography and, in the absence of nodal metastases, confirmatory mediastinoscopy according to current guidelines. However, randomized data regarding immediate lung tumor resection after systematic endosonography versus additional confirmatory mediastinoscopy before resection are lacking.METHODS:Patients with (suspected) resectable NSCLC and an indication for mediastinal staging after negative systematic endosonography were randomly assigned to immediate lung tumor resection or confirmatory mediastinoscopy followed by tumor resection. The primary outcome in this noninferiority trial (noninferiority margin of 8% that previously showed to not compromise survival, Pnoninferior &lt;.0250) was the presence of unforeseen N2 disease after tumor resection with lymph node dissection. Secondary outcomes were 30-day major morbidity and mortality.RESULTS:Between July 17, 2017, and October 5, 2020, 360 patients were randomly assigned, 178 to immediate lung tumor resection (seven dropouts) and 182 to confirmatory mediastinoscopy first (seven dropouts before and six after mediastinoscopy). Mediastinoscopy detected metastases in 8.0% (14/175; 95% CI, 4.8 to 13.0) of patients. Unforeseen N2 rate after immediate resection (8.8%) was noninferior compared with mediastinoscopy first (7.7%) in both intention-to-treat (Δ, 1.03%; UL 95% CIΔ, 7.2%; Pnoninferior =.0144) and per-protocol analyses (Δ, 0.83%; UL 95% CIΔ, 7.3%; Pnoninferior =.0157). Major morbidity and 30-day mortality was 12.9% after immediate resection versus 15.4% after mediastinoscopy first (P =.4940).CONCLUSION:On the basis of our chosen noninferiority margin in the rate of unforeseen N2, confirmatory mediastinoscopy after negative systematic endosonography can be omitted in patients with resectable NSCLC and an indication for mediastinal staging.</p

ABSTRACT Improving the Java Memory Model Using CRF

This paper describes alternative memory semantics for Java programs using an enriched version of the Commit/Reconcile/Fence (CRF) memory model [16]. It outlines a set of reasonable practices for safe multithreaded programming in Java. Our semantics allow a number of optimizations such as load reordering that are currently prohibited. Simple thread-local algebraic rules express the effects of optimizations at the source or bytecode level. The rules focus on reordering source-level operations; they yield a simple dependency analysis algorithm for Java. An instruction-by-instruction translation of Java memory operations into CRF operations captures thread interactions precisely. The fine-grained synchronization of CRF means the algebraic rules are easily derived from the translation. CRF can be mapped directly to a modern architecture, and is thus a suitable target for optimizing memory coherence during code generation

Improving the Java memory model using CRF

We describe an alternative memory semantics for Java programs using an enriched version of the Commit/Reconcile/Fence (CRF) memory model [SAR99]. We need to enrich CRF with semantics for Java&apos;s monitor-style locking, and with an instruction to mark cached data which will never change so that we can give semantics for nal slots. With these enrichments, we give an instruction-by-instruction translation of Java memory operations into CRF operations. The resulting Java memory semantics allow anumber of optimizations such as load reordering that are currently prohibited. Using the translation, we develop a simple thread-local algebraic semantics for Java so that optimizations can be expressed at the source or bytecode level. Finally, we show how the given semantics can be applied to give a simple dependency analysis algorithm for Java.